using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.IO;
using System;

public class Wei_Information_Manager : MonoBehaviour
{
    // 单例模式
    public static Wei_Information_Manager Instance { get; private set; }

    // 引用区域管理器和将军管理器
    [SerializeField] private Area_Manager areaManager;
    [SerializeField] private Wei_General_Manager generalManager;

    // 引用DeepSeek对话管理器
    [SerializeField] private Wei_DeepSeekDialogueManager deepSeekManager;

    // 信息刷新频率（秒）
    [SerializeField] private float updateInterval = 10f;

    // 导出路径
    private string infoFolderPath;
    private string combinedInfoPath;

    // 初始请求是否完成的标志
    private bool isInitialRequestCompleted = false;

    // 统计计数器
    private int updateCounter = 0;

    void Awake()
    {
        // 实现单例模式
        if (Instance == null)
        {
            Instance = this;
            DontDestroyOnLoad(gameObject);
        }
        else if (Instance != this)
        {
            Destroy(gameObject);
        }

        // 设置导出路径
        infoFolderPath = Path.Combine(Application.dataPath, "Scripts/Wu_test/Wei/Wei_Information");
    }

    void Start()
    {
        // 自动查找组件
        if (areaManager == null) areaManager = FindObjectOfType<Area_Manager>();
        if (generalManager == null) generalManager = FindObjectOfType<Wei_General_Manager>();
        if (deepSeekManager == null) deepSeekManager = FindObjectOfType<Wei_DeepSeekDialogueManager>();

        // 确保目录存在
        Directory.CreateDirectory(infoFolderPath);

        // 清理旧文件和潜在冲突文件
        CleanUpLegacyFiles();

        // 重置计数器并清理旧文件
        ResetCounter();

        // 启动初始请求并设置回调
        StartInitialRequest();
    }

    // 重置计数器并清理旧文件
    private void ResetCounter()
    {
        updateCounter = 0;

        // 清理旧的统计文件（可选）
        try
        {
            string[] oldFiles = Directory.GetFiles(infoFolderPath, "stats_*.json");
            foreach (string file in oldFiles)
            {
                File.Delete(file);
                Debug.Log($"已删除旧统计文件: {file}");
            }
        }
        catch (System.Exception e)
        {
            Debug.LogWarning($"清理旧文件时出错: {e.Message}");
        }
    }

    // 发起初始请求
    private void StartInitialRequest()
    {
        Debug.Log("发送初始对话请求...");

        // 增加检查，确保初始请求只被调用一次
        if (deepSeekManager.npcCharacter.GetCurrentTurn() > 0)
        {
            Debug.Log("【流程控制】检测到已经有过对话请求，跳过初始请求");
            isInitialRequestCompleted = true;
            StartCoroutine(UpdateInformationRoutine());
            return;
        }

        deepSeekManager.SendInitialDialogueRequest((response, success) =>
        {
            if (success)
            {
                Debug.Log("【流程控制】初始AI决策已生成，标记初始请求已完成");
                Debug.Log($"【流程控制】AI回复内容: {response?.Substring(0, Math.Min(100, response?.Length ?? 0))}...");
                isInitialRequestCompleted = true;

                // 触发侦察兵处理初始决策，而不是直接应用
                Wei_Scout scout = FindObjectOfType<Wei_Scout>();
                if (scout != null)
                {
                    Debug.Log("【流程控制】触发侦察兵提取并传递初始决策");
                    scout.ForceExtractAndDeliver();
                }
                else
                {
                    Debug.LogError("【流程控制】未找到侦察兵组件！尝试使用将军控制器作为后备...");
                    // 作为后备，尝试使用将军控制器
                    Wei_General_Controller generalController = FindObjectOfType<Wei_General_Controller>();
                    if (generalController != null)
                    {
                        Debug.Log("【流程控制】使用将军控制器应用初始决策");
                        generalController.ForceApplyDecisions();
                    }
                    else
                    {
                        Debug.LogError("【流程控制】未找到将军控制器组件！");
                    }
                }

                // 只有在初始请求成功后，才启动定期更新协程
                Debug.Log("【流程控制】开始启动定期情报收集协程...");
                StartCoroutine(UpdateInformationRoutine());
            }
            else
            {
                Debug.LogError("【流程控制】初始AI请求失败，请检查连接并重试");
            }
        });
    }

    // 定时更新情报的协程
    private IEnumerator UpdateInformationRoutine()
    {
        Debug.Log("【流程控制】开始定期收集魏国情报流程...");

        // 再次确认初始请求已完成
        if (!isInitialRequestCompleted)
        {
            Debug.LogError("【流程控制】严重错误：尝试启动情报收集协程，但初始请求尚未完成！");
            yield break;
        }

        // 检查决策栈是否已有内容
        int decisionCount = deepSeekManager.jsonStack.Count;
        Debug.Log($"【流程控制】当前决策栈中有 {decisionCount} 个决策");

        // 初始决策已生成，等待60秒后再开始第一次情报收集
        Debug.Log("【流程控制】等待60秒后开始第一次情报收集...");
        yield return new WaitForSeconds(60f);
        Debug.Log("【流程控制】等待结束，开始第一次情报收集");

        // 第一次更新
        UpdateAllInformation();

        // 向AI发送第一次情报更新
        Debug.Log("【流程控制】第一次情报收集完成，准备发送给AI");
        SendInformationToAI();

        Debug.Log("【流程控制】已完成第一次情报收集并发送给AI");

        // 然后使用循环来定期更新，但每次AI产生决策后需要等待60秒
        while (true)
        {
            // 等待AI做出决策的时间已包含在SendInformationToAI的回调中
            // 此处不需要等待，等待会在SendInformationToAI回调成功后加入
            yield return null;
        }
    }

    // 更新所有情报
    public void UpdateAllInformation()
    {
        updateCounter++;
        Debug.Log($"收集最新魏国情报 (第{updateCounter}次)...");

        // 设置当前统计的文件路径
        string areaInfoPath = Path.Combine(infoFolderPath, $"area_info_{updateCounter}.json");
        string generalInfoPath = Path.Combine(infoFolderPath, $"general_info_{updateCounter}.json");
        combinedInfoPath = Path.Combine(infoFolderPath, $"stats_{updateCounter}.json");

        // 更新区域信息（自定义路径）
        ExportWeiAreas(areaInfoPath);

        // 更新将军信息（自定义路径）
        ExportGenerals(generalInfoPath);

        // 合并信息到一个文件
        CombineInformation(areaInfoPath, generalInfoPath, combinedInfoPath);

        Debug.Log($"魏国情报更新 #{updateCounter} 已完成");
    }

    // 导出魏国区域信息到指定路径
    private void ExportWeiAreas(string filePath)
    {
        if (areaManager != null)
        {
            areaManager.ExportCountryAreasToJson("魏国", Path.GetDirectoryName(filePath), Path.GetFileName(filePath));
        }
        else
        {
            Debug.LogError("区域管理器不可用");
        }
    }

    // 导出魏国将军信息到指定路径
    private void ExportGenerals(string filePath)
    {
        if (generalManager != null)
        {
            generalManager.ExportGeneralsInfoToFile(filePath);
        }
        else
        {
            Debug.LogError("将军管理器不可用");
        }
    }

    // 合并区域和将军信息到一个文件
    private void CombineInformation(string areaInfoPath, string generalInfoPath, string targetPath)
    {
        try
        {
            // 读取区域信息
            string areaInfo = File.Exists(areaInfoPath) ? File.ReadAllText(areaInfoPath) : "[]";

            // 读取将军信息
            string generalInfo = File.Exists(generalInfoPath) ? File.ReadAllText(generalInfoPath) : "[]";

            // 合并信息
            string combinedInfo = "{\n";
            combinedInfo += "  \"count\": " + updateCounter + ",\n";
            combinedInfo += "  \"areas\": " + areaInfo + ",\n";
            combinedInfo += "  \"generals\": " + generalInfo + "\n";
            combinedInfo += "}";

            // 保存合并的信息
            File.WriteAllText(targetPath, combinedInfo);
            Debug.Log($"合并情报已保存到: {targetPath}");

            // 删除原始文件
            if (File.Exists(areaInfoPath))
            {
                File.Delete(areaInfoPath);
                Debug.Log($"已删除区域信息文件: {areaInfoPath}");
            }

            if (File.Exists(generalInfoPath))
            {
                File.Delete(generalInfoPath);
                Debug.Log($"已删除将军信息文件: {generalInfoPath}");
            }

#if UNITY_EDITOR
            UnityEditor.AssetDatabase.Refresh();
#endif
        }
        catch (System.Exception e)
        {
            Debug.LogError($"合并情报时出错: {e.Message}");
        }
    }

    // 向AI发送最新情报
    public void SendInformationToAI()
    {
        // 检查初始请求是否已完成
        if (!isInitialRequestCompleted)
        {
            Debug.LogError("【流程控制】严重错误：尝试发送情报更新，但初始请求尚未完成！中止操作。");
            return;
        }

        // 检查决策栈是否为空，如果不为空，可能上一轮决策还未处理完毕
        if (deepSeekManager.jsonStack.Count > 0)
        {
            Debug.LogWarning($"【流程控制】警告：决策栈不为空（当前有 {deepSeekManager.jsonStack.Count} 个决策），上一轮可能未处理完毕。推迟发送新情报。");
            // 安排在60秒后再次尝试，而不是立即发送
            StartCoroutine(DelayedSendInformation(60f));
            return;
        }

        if (deepSeekManager == null)
        {
            Debug.LogError("【流程控制】未找到DeepSeek对话管理器");
            return;
        }

        if (string.IsNullOrEmpty(combinedInfoPath) || !File.Exists(combinedInfoPath))
        {
            Debug.LogError("【流程控制】找不到最新的情报文件");
            return;
        }

        try
        {
            Debug.Log($"【流程控制】开始发送第{updateCounter}次情报给AI...");
            Debug.Log($"【流程控制】使用文件: {combinedInfoPath}");

            // 直接发送文件路径，而不是读取文件内容
            deepSeekManager.SendUpdateRequestFromFile(combinedInfoPath, false, (response, success) =>
            {
                if (success)
                {
                    Debug.Log($"【流程控制】AI已收到第{updateCounter}次情报并生成决策");
                    Debug.Log($"【流程控制】决策开头: {response?.Substring(0, Math.Min(100, response?.Length ?? 0))}...");

                    // 在传递决策之前先检查决策栈状态
                    Debug.Log($"【流程控制】AI生成决策后，决策栈中有 {deepSeekManager.jsonStack.Count} 个决策");

                    // 触发侦察兵提取并传递决策，而不是直接应用
                    Wei_Scout scout = FindObjectOfType<Wei_Scout>();
                    if (scout != null)
                    {
                        Debug.Log("【流程控制】触发侦察兵提取并传递最新决策");
                        scout.ForceExtractAndDeliver();

                        // 添加延迟检查，确保侦察兵成功清空了决策栈
                        StartCoroutine(VerifyDecisionStackCleared());
                    }
                    else
                    {
                        Debug.LogError("【流程控制】未找到侦察兵组件！尝试使用将军控制器作为后备...");
                        // 作为后备，尝试使用将军控制器
                        Wei_General_Controller generalController = FindObjectOfType<Wei_General_Controller>();
                        if (generalController != null)
                        {
                            Debug.Log("【流程控制】使用将军控制器应用最新决策");
                            generalController.ForceApplyDecisions();
                        }
                        else
                        {
                            Debug.LogError("【流程控制】未找到将军控制器组件！");
                        }
                    }

                    // AI生成决策后，等待设定时间再进行下一次信息收集
                    StartCoroutine(WaitAndUpdateAgain());
                }
                else
                {
                    Debug.LogError("【流程控制】发送情报给AI失败");

                    // 即使失败也尝试继续，但等待时间更长
                    StartCoroutine(WaitAndUpdateAgain(180f)); // 失败后等待3分钟再尝试
                }
            });
        }
        catch (System.Exception e)
        {
            Debug.LogError($"【流程控制】发送情报给AI时出错: {e.Message}");
            // 发生异常也尝试继续
            StartCoroutine(WaitAndUpdateAgain(180f));
        }
    }

    // 新增方法：延迟发送情报
    private IEnumerator DelayedSendInformation(float delayTime)
    {
        Debug.Log($"【流程控制】延迟 {delayTime} 秒后再次尝试发送情报...");
        yield return new WaitForSeconds(delayTime);

        // 再次检查决策栈
        if (deepSeekManager.jsonStack.Count > 0)
        {
            Debug.LogWarning($"【流程控制】延迟后决策栈仍不为空（当前有 {deepSeekManager.jsonStack.Count} 个决策），强制清空栈");
            deepSeekManager.jsonStack.Clear();
        }

        Debug.Log("【流程控制】延迟结束，现在发送情报");
        // 递归调用发送方法，但不会无限递归，因为我们已经清空决策栈
        SendInformationToAI();
    }

    // 新增方法：验证决策栈是否被正确清空
    private IEnumerator VerifyDecisionStackCleared()
    {
        // 等待2秒，让侦察兵完成提取和处理
        yield return new WaitForSeconds(2f);

        // 检查决策栈是否为空
        if (deepSeekManager.jsonStack.Count > 0)
        {
            // Debug.LogError($"【流程控制】警告：侦察兵提取决策后，决策栈仍有 {deepSeekManager.jsonStack.Count} 个决策！这可能导致决策重复执行。");

            // 强制清空决策栈以避免重复
            deepSeekManager.jsonStack.Clear();
            Debug.Log("【流程控制】已强制清空决策栈以避免命令重复执行");
        }
        else
        {
            Debug.Log("【流程控制】确认：侦察兵成功清空了决策栈");
        }
    }

    // 等待一段时间后进行下一次更新
    private IEnumerator WaitAndUpdateAgain(float waitTime = 90f)
    {
        Debug.Log($"【流程控制】上一轮决策已生成，等待{waitTime}秒后进行下一次情报收集...");

        // 等待指定时间
        yield return new WaitForSeconds(waitTime);

        // 再次检查决策栈是否已清空
        if (deepSeekManager.jsonStack.Count > 0)
        {
            Debug.LogWarning($"【流程控制】等待后决策栈仍不为空（当前有 {deepSeekManager.jsonStack.Count} 个决策），强制清空栈");
            deepSeekManager.jsonStack.Clear();
        }

        Debug.Log("【流程控制】等待时间结束，开始下一次情报收集");
        UpdateAllInformation();
        SendInformationToAI();
    }

    // 手动触发情报更新
    public void TriggerInformationUpdate()
    {
        if (!isInitialRequestCompleted)
        {
            Debug.LogError("【流程控制】严重错误：手动触发情报更新失败，初始请求尚未完成！");
            return;
        }

        // 检查上一次的更新是否已完成
        if (deepSeekManager.npcCharacter.GetCurrentTurn() != updateCounter)
        {
            Debug.LogWarning($"【流程控制】警告：上一次更新({updateCounter})可能尚未完成，当前AI回合为{deepSeekManager.npcCharacter.GetCurrentTurn()}");
        }

        Debug.Log("【流程控制】手动触发情报更新");
        UpdateAllInformation();
        SendInformationToAI();
    }

    // 清理可能造成干扰的旧文件
    private void CleanUpLegacyFiles()
    {
        Debug.Log("【流程控制】正在清理可能干扰的旧文件...");

        // 清理可能的固定名称文件
        string legacyGeneralFile = Path.Combine(infoFolderPath, "generalInfo.json");
        string legacyAreaFile = Path.Combine(infoFolderPath, "areaInformation.json");

        if (File.Exists(legacyGeneralFile))
        {
            try
            {
                File.Delete(legacyGeneralFile);
                Debug.Log($"【流程控制】已删除旧的固定名称将军文件: {legacyGeneralFile}");
            }
            catch (Exception e)
            {
                Debug.LogWarning($"【流程控制】删除旧文件失败: {e.Message}");
            }
        }

        if (File.Exists(legacyAreaFile))
        {
            try
            {
                File.Delete(legacyAreaFile);
                Debug.Log($"【流程控制】已删除旧的固定名称区域文件: {legacyAreaFile}");
            }
            catch (Exception e)
            {
                Debug.LogWarning($"【流程控制】删除旧文件失败: {e.Message}");
            }
        }

        // 查找并删除分散的单个将军文件
        string[] singleGeneralFiles = Directory.GetFiles(infoFolderPath, "decision_*.json");
        foreach (string file in singleGeneralFiles)
        {
            try
            {
                File.Delete(file);
                Debug.Log($"【流程控制】已删除分散的将军决策文件: {file}");
            }
            catch (Exception e)
            {
                Debug.LogWarning($"【流程控制】删除文件失败: {e.Message}");
            }
        }

        Debug.Log("【流程控制】文件清理完成");
    }
}